package com.cloud.service.impl;

import com.joyoung.common.controller.PageInfoRes;
import com.joyoung.common.controller.RestRes;
import com.joyoung.common.exception.exceptions.BusinessException;
import com.cloud.feign.resp.*;
import com.cloud.feign.service.CloudProductFeign;
import com.cloud.feign.service.LogisticsWorkbenchWmsFeign;
import com.cloud.feign.service.MesReportFeign;
import com.cloud.resp.*;
import com.cloud.service.ProductTraceSourceService;
import com.cloud.utils.BeanConvertUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;

@Service
@Slf4j
public class ProductTraceSourceServiceImpl implements ProductTraceSourceService {
    @Autowired
    private CloudProductFeign cloudProductFeign;
    @Autowired
    private MesReportFeign mesReportFeign;
    @Autowired
    private LogisticsWorkbenchWmsFeign logisticsWorkbenchWmsFeign;
    @Autowired
    @Qualifier("selectExecutor")
    private Executor selectExecutor;

    @Override
    public ProductTraceSourceDto queryProductByBarCode(String barCode) throws Exception {

        if (StringUtils.isEmpty(barCode)) {
            throw new BusinessException("请输入产品码");
        }
        if (barCode.length() < 10) {
            throw new BusinessException("该产品码长度不正确");
        }
        ProductTraceSourceDto productTraceSourceDto = new ProductTraceSourceDto();

        CompletableFuture<Void> buildProductTraceSourceBaseFuture = CompletableFuture.runAsync(() -> {
            //创建 产品溯源-基础信息
            buildProductTraceSourceBaseDto(productTraceSourceDto, barCode);
        }, selectExecutor);

        CompletableFuture<Void> buildProductTraceSourceAccessoryFuture = CompletableFuture.runAsync(() -> {
            //创建 产品溯源-配件信息
            buildProductTraceSourceAccessory(productTraceSourceDto, barCode);
        }, selectExecutor);

        CompletableFuture<Void> buildProductTraceSourceManufacturingFuture = CompletableFuture.runAsync(() -> {
            //创建 产品溯源-制造信息
            buildProductTraceSourceManufacturing(productTraceSourceDto, barCode);
        }, selectExecutor);

        CompletableFuture<Void> buildProductTraceSourceLogisticsFuture = CompletableFuture.runAsync(() -> {
            //创建 产品溯源-物流信息
            buildProductTraceSourceLogistics(productTraceSourceDto, barCode);
        }, selectExecutor);

        CompletableFuture<Void> buildProductTraceSourceAfterSaleFuture = CompletableFuture.runAsync(() -> {
            //创建 产品溯源-售后信息
            buildProductTraceSourceAfterSale(productTraceSourceDto, barCode);
        }, selectExecutor);

        CompletableFuture.allOf(buildProductTraceSourceBaseFuture, buildProductTraceSourceAccessoryFuture,
                buildProductTraceSourceManufacturingFuture, buildProductTraceSourceLogisticsFuture, buildProductTraceSourceAfterSaleFuture).get();
        return productTraceSourceDto;
    }

    /**
     * 创建 产品溯源-基础信息
     **/
    private void buildProductTraceSourceBaseDto(ProductTraceSourceDto productTraceSourceDto, String barCode) {

        // 调用MES获取产品码对应商品编码
        RestRes<ProductBasicInfo> productBasicInfo = mesReportFeign.getProductBasicInfo(barCode);
        ProductBasicInfo productBasic = productBasicInfo.getData();
        if (productBasic == null || StringUtils.isEmpty(productBasic.getProductCode())) {
            log.error("查询MES产品基础数据结果为空，产品码: {}", barCode);
            throw new BusinessException("此产品码不存在");
        }
        ProductTraceSourceBaseDto productTraceSourceBaseDto =
                BeanConvertUtil.convert(productBasic, ProductTraceSourceBaseDto.class);

        // 拉取主数据商品信息
        RestRes<PageInfoRes<GoodsTmsVo>> page = cloudProductFeign.getPage(
                null, null, 0, null, 1, 10, null, productTraceSourceBaseDto.getProductCode(), null);
        List<GoodsTmsVo> goodsTmsVos = page.getData().getContent();
        if (CollectionUtils.isEmpty(goodsTmsVos)) {
            log.error("查询主数据结果为空，商品编码: {}", productTraceSourceBaseDto.getProductCode());
            throw new BusinessException("此产品码不存在");
        }
        // 拉取商品图片
        RestRes<GoodsDetailVo> details = cloudProductFeign.getDetails(productTraceSourceBaseDto.getProductCode());
        if (details.getData() != null && !CollectionUtils.isEmpty(details.getData().getPoster())) {
            // 图片
            productTraceSourceBaseDto.setPicture(details.getData().getVideoAndSlideShow().get(0).getValue());
        }

        // 产品码
        productTraceSourceBaseDto.setProductBarCode(barCode);
//        // 物料编码
//        productTraceSourceBaseDto.setProductCode();
//        // 物料名称
//        productTraceSourceBaseDto.setProductName();
        // 型号
        productTraceSourceBaseDto.setModel(goodsTmsVos.get(0).getModel());
        // 系列  暂时为空
        productTraceSourceBaseDto.setSubItem(null);
        // 69码
        productTraceSourceBaseDto.setNationalCode(goodsTmsVos.get(0).getNationalCode());
        // 平台编码
        productTraceSourceBaseDto.setProductPlatformCode(goodsTmsVos.get(0).getPlatformCode());
        // 平台名称
        productTraceSourceBaseDto.setProductPlatformName(goodsTmsVos.get(0).getPlatformName());

        productTraceSourceDto.setProductTraceSourceBaseDto(productTraceSourceBaseDto);

    }

    /**
     * 创建 产品溯源-配件信息
     **/
    private void buildProductTraceSourceAccessory(ProductTraceSourceDto productTraceSourceDto, String barCode) {

        RestRes<KeyAccessoryInfo> keyAccessoryInfo = mesReportFeign.getKeyAccessoryInfo(barCode);
        KeyAccessoryInfo keyAccessory = keyAccessoryInfo.getData();
        if (keyAccessory != null) {
            if (CollectionUtils.isEmpty(keyAccessory.getProductAccessoryExams())) {
                log.info("MES系统未查询到产品溯源-关键配件质检信息,产品码: {}", barCode);
            } else {
                // 产品溯源关键配件-关键配件质检
                List<ProductTraceSourceAccessoryExamDto> productAccessoryExams =
                        BeanConvertUtil.convertList(keyAccessory.getProductAccessoryExams(), ProductTraceSourceAccessoryExamDto.class);
                productTraceSourceDto.setProductAccessoryExams(productAccessoryExams);
            }
            if (CollectionUtils.isEmpty(keyAccessory.getProductAccessoryAssembles())) {
                log.info("MES系统未查询到产品溯源-关键配件组装信息,产品码: {}", barCode);
            } else {
                // 产品溯源关键配件-关键配件组装
                List<ProductTraceSourceAccessoryAssembleDto> productAccessoryAssembles =
                        BeanConvertUtil.convertList(keyAccessory.getProductAccessoryAssembles(), ProductTraceSourceAccessoryAssembleDto.class);
                productTraceSourceDto.setProductAccessoryAssembles(productAccessoryAssembles);
            }
        } else {
            log.info("MES系统未查询到产品溯源-配件信息,产品码: {}", barCode);
        }
    }

    /**
     * 创建 产品溯源-制造信息
     **/
    private void buildProductTraceSourceManufacturing(ProductTraceSourceDto productTraceSourceDto, String barCode) {

        RestRes<ManufacturingProcessInfo> manufacturingProcessInfo = mesReportFeign.getManufacturingProcess(barCode);
        ManufacturingProcessInfo manufacturingProcess = manufacturingProcessInfo.getData();

        if (manufacturingProcess != null) {
            if (manufacturingProcess.getManufactureBasicInfo() == null) {
                log.info("MES系统未查询到产品溯源-制造过程基础信息,产品码: {}", barCode);
            } else {
                // 产品溯源制造过程-基础信息
                ProductTraceSourceProduceBaseDto produceBases =
                        BeanConvertUtil.convert(manufacturingProcess.getManufactureBasicInfo(), ProductTraceSourceProduceBaseDto.class);
                productTraceSourceDto.setProduceBase(produceBases);
            }
            if (CollectionUtils.isEmpty(manufacturingProcess.getProductExams())) {
                log.info("MES系统未查询到产品溯源-制造过程质检信息,产品码: {}", barCode);
            } else {
                // 产品溯源制造过程-产品质检相关信息
                List<ProductTraceSourceExamDto> productExams =
                        BeanConvertUtil.convertList(manufacturingProcess.getProductExams(), ProductTraceSourceExamDto.class);
                productTraceSourceDto.setProductExams(productExams);
            }
            if (CollectionUtils.isEmpty(manufacturingProcess.getProductRepairs())) {
                log.info("MES系统未查询到产品溯源-制造过程维修信息,产品码: {}", barCode);
            } else {
                // 产品溯源制造过程-维修状态信息
                List<ProductTraceSourceRepairDto> productRepairs =
                        BeanConvertUtil.convertList(manufacturingProcess.getProductRepairs(), ProductTraceSourceRepairDto.class);
                productTraceSourceDto.setProductRepairs(productRepairs);
            }
        } else {
            log.info("MES系统未查询到产品溯源-制造过程信息,产品码: {}", barCode);
        }
    }

    /**
     * 创建 产品溯源-物流信息
     **/
    private void buildProductTraceSourceLogistics(ProductTraceSourceDto productTraceSourceDto, String barCode) {

        RestRes<LogisticsInfoDto> logisticsInfo = logisticsWorkbenchWmsFeign.getLogisticsInfo(barCode);
        LogisticsInfoDto logistics = logisticsInfo.getData();
        if (logistics != null) {
            if (logistics.getLogisticsStatusInfo() == null) {
                log.info("JLP系统未查询到产品溯源-物流状态信息,产品码: {}", barCode);
            } else {
                // 产品溯源物流信息-物流状态
                ProductTraceSourceLogisticsDto productLogistics =
                        BeanConvertUtil.convert(logistics.getLogisticsStatusInfo(), ProductTraceSourceLogisticsDto.class);
                productTraceSourceDto.setProductLogistics(productLogistics);
            }
            if (CollectionUtils.isEmpty(logistics.getStorageRecordDtoList())) {
                log.info("JLP系统未查询到产品溯源-出入库明细信息,产品码: {}", barCode);
            } else {
                // 产品溯源物流信息-出入库明细
                List<ProductTraceSourceStockStorageRecordDto> productStockStorageRecords =
                        BeanConvertUtil.convertList(logistics.getStorageRecordDtoList(), ProductTraceSourceStockStorageRecordDto.class);
                productTraceSourceDto.setProductStockStorageRecords(productStockStorageRecords);
            }

        } else {
            log.info("JLP系统未查询到产品溯源-物流信息,产品码: {}", barCode);
        }
    }

    /**
     * 创建 产品溯源-售后信息
     **/
    private void buildProductTraceSourceAfterSale(ProductTraceSourceDto productTraceSourceDto, String barCode) {

        //Todo  月底前 获取
    }
}
